TypeScript rekursiv tiplarini oʻzlashtirish: Oʻz-oʻziga murojaat qiluvchi taʼriflarga chuqur shoʻngʻish

Dasturiy taʼminotni ishlab chiqish dunyosida biz koʻpincha tabiiy ravishda ichki yoki ierarxik boʻlgan maʼlumot tuzilmalariga duch kelamiz. Fayl tizimlari, tashkiliy jadvallar, ijtimoiy media platformasidagi sharhlar yoki JSON obʼektining oʻz tuzilishini oʻylab koʻring. Bu murakkab, oʻz-oʻziga murojaat qiluvchi tuzilmalarni tip-xavfsiz tarzda qanday ifodalaymiz? Javob TypeScriptʼning eng kuchli xususiyatlaridan birida: rekursiv tiplarda.

Ushbu keng qamrovli qoʻllanma sizni rekursiv tiplarning asosiy tushunchalaridan tortib ilgʻor ilovalar va eng yaxshi amaliyotlarga qadar sayohatga olib boradi. Siz TypeScript boʻyicha bilimingizni chuqurlashtirishni istagan tajribali dasturchi boʻlasizmi yoki murakkabroq maʼlumotlarni modellashtirish muammolarini hal qilishni maqsad qilgan oʻrta darajadagi dasturchi boʻlasizmi, ushbu maqola sizni rekursiv tiplarni ishonch va aniqlik bilan ishlatish uchun bilimlar bilan qurollantiradi.

Rekursiv Tiplar Nima? Oʻz-oʻziga Murojaat Qilish Kuchi

Aslini olganda, rekursiv tip – bu oʻziga oʻzi murojaat qiluvchi tip taʼrifi. Bu tip tizimining rekursiv funksiyaga ekvivalenti — yaʼni oʻzini chaqiradigan funksiya. Bu oʻz-oʻziga murojaat qilish qobiliyati bizga ixtiyoriy yoki nomaʼlum chuqurlikka ega maʼlumot tuzilmalari uchun tiplarni aniqlash imkonini beradi.

Oddiy real hayotiy analogiya – bu rus ichma-ich qoʻgʻirchogʻi (Matryoshka) tushunchasi. Har bir qoʻgʻirchoq oʻzida kichikroq, aynan oʻxshash qoʻgʻirchoqni oʻz ichiga oladi, u ham oʻz navbatida boshqasini, va hokazo. Rekursiv tip buni mukammal tarzda modellashtirishi mumkin: a `Doll` bu `color` va `size` kabi xususiyatlarga ega boʻlgan tipdir va shuningdek, boshqa `Doll` boʻlgan ixtiyoriy xususiyatni ham oʻz ichiga oladi.

Rekursiv tiplarsiz, biz `any` yoki `unknown` kabi kamroq xavfsiz alternativalardan foydalanishga majbur boʻlardik, yoki cheklangan miqdordagi joylashtirish darajalarini aniqlashga urinardik (masalan, `Category`, `SubCategory`, `SubSubCategory`), bu esa moʻrt boʻlib, yangi joylashtirish darajasi talab qilinganda ishlamay qoladi. Rekursiv tiplar nafis, masshtablanuvchi va tip-xavfsiz yechimni taqdim etadi.

Asosiy rekursiv tipni aniqlash: Bogʻlangan roʻyxat

Klassik kompyuter fanlari maʼlumot tuzilmasidan boshlaylik: bogʻlangan roʻyxat. Bogʻlangan roʻyxat – bu tugunlar ketma-ketligi boʻlib, har bir tugun qiymatni va ketma-ketlikdagi keyingi tugunga havolani (yoki bogʻlamni) oʻz ichiga oladi. Oxirgi tugun roʻyxatning oxirini bildiruvchi `null` yoki `undefined` ga ishora qiladi.

Bu tuzilma oʻz-oʻzidan rekursivdir. `Node` oʻziga oʻzi nisbatan aniqlanadi. Buni TypeScriptʼda qanday modellashtirishimiz mumkinligi quyidagicha:

            
interface LinkedListNode {
  value: number;
  next: LinkedListNode | null;
}

            

              
                Copy
              
            
          

Ushbu misolda, `LinkedListNode` interfeysi ikkita xususiyatga ega:

• `value`: Bu holda, `number`. Keyinchalik buni umumiy (generic) qilamiz.
• `next`: Bu rekursiv qismdir. `next` xususiyati boshqa `LinkedListNode` yoki roʻyxatning oxiri boʻlsa `null` boʻladi.

Oʻz taʼrifida oʻziga murojaat qilish orqali, `LinkedListNode` istalgan uzunlikdagi tugunlar zanjirini tasvirlashi mumkin. Buni amalda koʻrib chiqaylik:

            
const node3: LinkedListNode = { value: 3, next: null };
const node2: LinkedListNode = { value: 2, next: node3 };
const node1: LinkedListNode = { value: 1, next: node2 };

// node1 is the head of the list: 1 -> 2 -> 3 -> null

function sumLinkedList(node: LinkedListNode | null): number {
  if (node === null) {
    return 0;
  }
  return node.value + sumLinkedList(node.next);
}

console.log(sumLinkedList(node1)); // Outputs: 6

            

              
                Copy
              
            
          

`sumLinkedList` funksiyasi bizning rekursiv tipimizga mukammal hamrohdir. Bu rekursiv maʼlumot tuzilmasini qayta ishlovchi rekursiv funksiya. TypeScript `LinkedListNode` ning shaklini tushunadi va toʻliq avtokompletatsiya va tip tekshiruvini taʼminlaydi, `node.next` `null` boʻlishi mumkin boʻlgan holatlarda `node.next.value` ga kirishga urinish kabi umumiy xatolarning oldini oladi.

Ierarxik maʼlumotlarni modellashtirish: Daraxt tuzilmasi

Bogʻlangan roʻyxatlar chiziqli boʻlsa-da, koʻplab real dunyo maʼlumotlar toʻplamlari ierarxikdir. Aynan shu yerda daraxt tuzilmalari oʻzini koʻrsatadi va rekursiv tiplar ularni modellashtirishning tabiiy usuli hisoblanadi.

1-misol: Boʻlimning tashkiliy jadvali

Har bir xodimning menejeri boʻlgan va menejerlar ham xodim boʻlgan tashkiliy jadvalni koʻrib chiqing. Xodim boshqa xodimlar jamoasini ham boshqarishi mumkin.

            
interface Employee {
  id: number;
  name: string;
  role: string;
  reports: Employee[]; // The recursive part!
}

const ceo: Employee = {
  id: 1,
  name: 'Alina Sterling',
  role: 'CEO',
  reports: [
    {
      id: 2,
      name: 'Ben Carter',
      role: 'CTO',
      reports: [
        {
          id: 4,
          name: 'David Chen',
          role: 'Lead Engineer',
          reports: []
        }
      ]
    },
    {
      id: 3,
      name: 'Carla Rodriguez',
      role: 'CFO',
      reports: []
    }
  ]
};

            

              
                Copy
              
            
          

Bu yerda, `Employee` interfeysi `reports` xususiyatini oʻz ichiga oladi, bu boshqa `Employee` obʼektlarining massividir. Bu boshqaruvning necha darajasi mavjudligidan qatʼi nazar, butun ierarxiyani nafis tarzda modellashtiradi. Biz bu daraxtni kezish uchun funksiyalar yozishimiz mumkin, masalan, maʼlum bir xodimni topish yoki boʻlimdagi umumiy odamlar sonini hisoblash.

2-misol: Fayl tizimi

Yana bir klassik daraxt tuzilmasi – bu fayllar va kataloglardan (papkalardan) tashkil topgan fayl tizimidir. Katalog ham fayllarni, ham boshqa kataloglarni oʻz ichiga olishi mumkin.

            
interface File {
  type: 'file';
  name: string;
  size: number; // in bytes
}

interface Directory {
  type: 'directory';
  name: string;
  contents: FileSystemNode[]; // The recursive part!
}

// A discriminated union for type safety
type FileSystemNode = File | Directory;

const root: Directory = {
  type: 'directory',
  name: 'project',
  contents: [
    {
      type: 'file',
      name: 'package.json',
      size: 256
    },
    {
      type: 'directory',
      name: 'src',
      contents: [
        {
          type: 'file',
          name: 'index.ts',
          size: 1024
        },
        {
          type: 'directory',
          name: 'components',
          contents: []
        }
      ]
    }
  ]
};

            

              
                Copy
              
            
          

Ushbu ilgʻorroq misolda, biz `FileSystemNode` birlashma tipidan foydalanamiz, bu obʼekt `File` yoki `Directory` boʻlishi mumkinligini ifodalaydi. `Directory` interfeysi oʻzining `contents` uchun rekursiv ravishda `FileSystemNode` dan foydalanadi. `type` xususiyati diskriminant vazifasini bajaradi, bu TypeScriptga `if` yoki `switch` shartlarida tipni toʻgʻri toraytirish imkonini beradi.

JSON bilan ishlash: Universal va amaliy dastur

Zamonaviy veb-ishlab chiqishda rekursiv tiplardan eng keng tarqalgan foydalanish holati JSON (JavaScript Object Notation) ni modellashtirishdir. JSON qiymati qator, raqam, boolean, null, JSON qiymatlari massivi yoki qiymatlari JSON qiymatlari boʻlgan obʼekt boʻlishi mumkin.

Rekursiyani payqadingizmi? Massiv elementlari JSON qiymatlari. Obʼektning xususiyatlari JSON qiymatlari. Bu oʻz-oʻziga murojaat qiluvchi tip taʼrifini talab qiladi.

Ixtiyoriy JSON uchun tipni aniqlash

Har qanday haqiqiy JSON tuzilmasi uchun mustahkam tipni qanday aniqlash mumkinligi quyidagicha. Bu namuna dinamik yoki oldindan aytib boʻlmaydigan JSON yuklamalarini qaytaruvchi APIʼlar bilan ishlashda nihoyatda foydalidir.

            
type JsonValue =
  | string
  | number
  | boolean
  | null
  | JsonValue[] // Recursive reference to an array of itself
  | { [key: string]: JsonValue }; // Recursive reference to an object of itself

// It's also common to define JsonObject separately for clarity:
type JsonObject = { [key: string]: JsonValue };

// And then redefine JsonValue like this:
type JsonValue = 
  | string
  | number
  | boolean
  | null
  | JsonValue[]
  | JsonObject;


            

              
                Copy
              
            
          

Bu oʻzaro rekursiyaning misolidir. `JsonValue` `JsonObject` (yoki inline obʼekt) orqali aniqlanadi, va `JsonObject` esa `JsonValue` orqali aniqlanadi. TypeScript bu dumaloq murojaatni silliq boshqaradi.

Misol: Tip-xavfsiz JSON Stringify funksiyasi

Bizning `JsonValue` tipimiz yordamida, biz faqat haqiqiy JSON-mos maʼlumot tuzilmalari bilan ishlaydigan, ish vaqtidagi xatolarning oldini oluvchi funksiyalarni yaratishimiz mumkin.

            
function processJson(data: JsonValue): void {
  if (typeof data === 'string') {
    console.log(`Found a string: ${data}`);
  } else if (Array.isArray(data)) {
    console.log('Processing an array...');
    data.forEach(processJson); // Recursive call
  } else if (typeof data === 'object' && data !== null) {
    console.log('Processing an object...');
    for (const key in data) {
      processJson(data[key]); // Recursive call
    }
  }
  // ... handle other primitive types
}

const myData: JsonValue = {
  user: 'Alex',
  is_active: true,
  session_data: {
    id: 12345,
    tokens: ['A', 'B', 'C']
  }
};

processJson(myData);

            

              
                Copy
              
            
          

`data` parametrini `JsonValue` sifatida tiplash orqali, biz `processJson` ga funksiya, `Date` obʼekti, `undefined` yoki boshqa seriyalashtirilmaydigan qiymatlarni oʻtkazishga boʻlgan har qanday urinish kompilyatsiya vaqtida xatoga olib kelishini taʼminlaymiz. Bu kodning mustahkamligini sezilarli darajada oshiradi.

Ilgʻor tushunchalar va potentsial tuzoqlar

Rekursiv tiplarni chuqurroq oʻrganganingizda, siz ilgʻorroq naqshlar va baʼzi umumiy muammolarga duch kelasiz.

Umumiy (Generic) rekursiv tiplar

Bizning dastlabki `LinkedListNode` qiymati uchun `number` dan foydalanishga qattiq bogʻlangan edi. Bu juda koʻp marta ishlatilmaydigan holat. Uni har qanday maʼlumot tipini qoʻllab-quvvatlash uchun umumiy (generic) qilishimiz mumkin.

            
interface GenericNode<T> {
  value: T;
  next: GenericNode<T> | null;
}

let stringNode: GenericNode<string> = { value: 'hello', next: null };
let numberNode: GenericNode<number> = { value: 123, next: null };

interface User { id: number; name: string; }
let userNode: GenericNode<User> = { value: { id: 1, name: 'Alex' }, next: null };

            

              
                Copy
              
            
          

`` tip parametrini kiritish orqali, bizning `GenericNode` endi qatorlar, raqamlar, obʼektlar yoki boshqa har qanday tipdagi bogʻlangan roʻyxatlarni yaratish uchun ishlatilishi mumkin, bu esa kod bazangiz boʻylab qayta ishlatilishini oshiradi.

Qoʻrqinchli xato: "Tip instansiyasi haddan tashqari chuqur va ehtimol cheksiz"

Baʼzida, ayniqsa murakkab rekursiv tipni aniqlashda, siz ushbu mashhur TypeScript xatosiga duch kelishingiz mumkin. Bu TypeScript kompilyatorining tiplarni hal qilishda cheksiz tsiklda qolib ketishdan oʻzini himoya qilish uchun oʻrnatilgan chuqurlik chegarasi mavjudligi sababli yuzaga keladi. Agar sizning tip taʼrifingiz juda toʻgʻridan-toʻgʻri yoki murakkab boʻlsa, u bu chegaraga yetishi mumkin.

Quyidagi muammoli misolni koʻrib chiqing:

            
// This can cause issues
type BadTuple = [string, BadTuple] | [];

            

              
                Copy
              
            
          

Bu toʻgʻri koʻrinsa-da, TypeScript tip aliaslarini kengaytirish usuli baʼzida bu xatoga olib kelishi mumkin. Buni hal qilishning eng samarali usullaridan biri `interface` dan foydalanishdir. Interfeyslar tip tizimida darhol kengaytirilmasdan murojaat qilish mumkin boʻlgan nomli tipni yaratadi, bu esa odatda rekursiyani ancha silliq boshqaradi.

            
// This is much safer
interface GoodTuple {
  head: string;
  tail: GoodTuple | null;
}

            

              
                Copy
              
            
          

Agar siz tip aliasidan foydalanishga majbur boʻlsangiz, baʼzida oraliq tipni kiritish yoki boshqa tuzilmadan foydalanish orqali toʻgʻridan-toʻgʻri rekursiyani buzishingiz mumkin. Biroq, umumiy qoida shundaki: murakkab obʼekt shakllari, ayniqsa rekursivlar uchun, `type` oʻrniga `interface` ni afzal koʻring.

Rekursiv shartli va xaritalangan tiplar

TypeScript tip tizimining haqiqiy kuchi xususiyatlarni birlashtirganda ochiladi. Rekursiv tiplar obʼekt tuzilmalarini chuqur oʻzgartirish uchun xaritalangan va shartli tiplar kabi ilgʻor yordamchi tiplar ichida ishlatilishi mumkin.

Klassik misol `DeepReadonly` boʻlib, u obʼektning va uning quyi obʼektlarining har bir xususiyatini rekursiv ravishda `readonly` qiladi.

            
type DeepReadonly<T> = T extends (...args: any[]) => any
  ? T
  : T extends object
  ? { readonly [P in keyof T]: DeepReadonly<T[P]> }
  : T;

interface UserProfile {
  id: number;
  details: {
    name: string;
    address: {
      city: string;
    };
  };
}

type ReadonlyUserProfile = DeepReadonly<UserProfile>;

// const profile: ReadonlyUserProfile = ...
// profile.id = 2; // Error!
// profile.details.name = 'New Name'; // Error!
// profile.details.address.city = 'New City'; // Error!

            

              
                Copy
              
            
          

Keling, ushbu kuchli yordamchi tipni tahlil qilamiz:

• U avval `T` funksiya ekanligini tekshiradi va uni oʻz holicha qoldiradi.
• Soʻngra `T` obʼekt ekanligini tekshiradi.
• Agar u obʼekt boʻlsa, `T` dagi har bir `P` xususiyatini xaritalaydi.
• Har bir xususiyat uchun `readonly` ni qoʻllaydi va keyin – bu kalit – u xususiyatning `T[P]` tipiga rekursiv ravishda `DeepReadonly` ni chaqiradi.
• Agar `T` obʼekt boʻlmasa (yaʼni, primitiv tip), u `T` ni oʻz holicha qaytaradi.

Rekursiv tip manipulyatsiyasining ushbu namunasi koʻplab ilgʻor TypeScript kutubxonalarining asosidir va nihoyatda mustahkam va ifodali yordamchi tiplarni yaratishga imkon beradi.

Rekursiv tiplardan foydalanish uchun eng yaxshi amaliyotlar

Rekursiv tiplardan samarali foydalanish va toza, tushunarli kod bazasini saqlash uchun quyidagi eng yaxshi amaliyotlarni koʻrib chiqing:

1. Ommaviy APIʼlar uchun Interfeyslarni afzal koʻring: Kutubxonaning ommaviy APIʼsi yoki umumiy modulining bir qismi boʻladigan rekursiv tipni aniqlashda, `interface` koʻpincha yaxshiroq tanlovdir. U rekursiyani yanada ishonchli boshqaradi va yaxshiroq xato xabarlarini taqdim etadi.
2. Oddiy holatlar uchun Tip Aliaslaridan foydalaning: Oddiy, lokal yoki birlashmaga asoslangan rekursiv tiplar (bizning `JsonValue` misolimiz kabi) uchun `type` aliyasi butunlay maqbul va koʻpincha ixchamroqdir.
3. Maʼlumot tuzilmalaringizni hujjatlashtiring: Murakkab rekursiv tipni bir qarashda tushunish qiyin boʻlishi mumkin. Tuzilma, uning maqsadi va misolini tushuntirish uchun TSDoc izohlaridan foydalaning.
4. Har doim asosiy holatni aniqlang: Xuddi rekursiv funksiya oʻz bajarilishini toʻxtatish uchun asosiy holatga muhtoj boʻlganidek, rekursiv tip ham yakunlash usuliga muhtoj. Bu odatda `null`, `undefined` yoki oʻz-oʻziga murojaat zanjirini toʻxtatadigan boʻsh massiv (`[]`) dir. Bizning `LinkedListNode` da asosiy holat `| null` edi.
5. Diskriminatsiyalangan birlashmalardan foydalaning: Agar rekursiv tuzilma turli xil tugunlarni oʻz ichiga olishi mumkin boʻlsa (bizning `File` va `Directory` bilan `FileSystemNode` misolimiz kabi), diskriminatsiyalangan birlashmadan foydalaning. Bu maʼlumotlar bilan ishlashda tip xavfsizligini sezilarli darajada yaxshilaydi.
6. Tiplaringiz va funksiyalaringizni sinab koʻring: Rekursiv maʼlumot tuzilmalarini isteʼmol qiladigan yoki ishlab chiqaradigan funksiyalar uchun birlik testlarini yozing. Boʻsh roʻyxat/daraxt, bir tugunli tuzilma va chuqur joylashtirilgan tuzilma kabi chegaraviy holatlarni qamrab olganingizga ishonch hosil qiling.

Xulosa: Murakkablikni nafislik bilan qabul qilish

Rekursiv tiplar nafaqat kutubxona mualliflari uchun gʻayrioddiy xususiyat; ular real dunyoni modellashtirishi kerak boʻlgan har qanday TypeScript dasturchisi uchun asosiy vositadir. Oddiy roʻyxatlardan murakkab JSON daraxtlarigacha va domenlarga xos ierarxik maʼlumotlargacha, oʻz-oʻziga murojaat qiluvchi taʼriflar mustahkam, oʻz-oʻzini hujjatlashtiruvchi va tip-xavfsiz ilovalarni yaratish uchun qolipni taqdim etadi.

Rekursiv tiplarni qanday aniqlash, ishlatish va generiklar va shartli tiplar kabi boshqa ilgʻor xususiyatlar bilan birlashtirishni tushunish orqali siz TypeScript koʻnikmalaringizni oshirishingiz va ham bardoshli, ham tushunish osonroq boʻlgan dasturiy taʼminotni yaratishingiz mumkin. Keyingi safar ichki maʼlumotlar tuzilmasiga duch kelganingizda, uni nafislik va aniqlik bilan modellashtirish uchun mukammal vositaga ega boʻlasiz.